home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / minix / up1510b.tgz / up1510b / src / mm / exec.c.D < prev    next >
Text File  |  1990-07-25  |  8KB  |  262 lines
  1. *** /tmp/,RCSt1022399    Wed Jul 25 13:59:41 1990
  2. --- exec.c    Mon Jul 23 16:16:34 1990
  3. ***************
  4. *** 14,22 ****
  5.   
  6. ! #include "../h/const.h"
  7. ! #include "../h/type.h"
  8. ! #include "../h/callnr.h"
  9. ! #include "../h/error.h"
  10. ! #include "../h/stat.h"
  11. ! #include "const.h"
  12. ! #include "glo.h"
  13.   #include "mproc.h"
  14. --- 14,18 ----
  15.   
  16. ! #include "mm.h"
  17. ! #include <sys/stat.h>
  18. ! #include <minix/callnr.h>
  19.   #include "mproc.h"
  20. ***************
  21. *** 24,26 ****
  22. --- 20,26 ----
  23.   
  24. + #if INTEL_32BITS
  25. + #define MAGIC    0x10000301L
  26. + #else
  27.   #define MAGIC    0x04000301L    /* magic number with 2 bits masked off */
  28. + #endif
  29.   #define SEP      0x00200000L    /* value for separate I & D */
  30. ***************
  31. *** 32,35 ****
  32.   
  33. ! #ifdef ATARI_ST
  34. ! PUBLIC long lseek();
  35.   #endif
  36. --- 32,40 ----
  37.   
  38. ! FORWARD void load_seg();
  39. ! FORWARD int new_mem();
  40. ! FORWARD void patch_ptr();
  41. ! FORWARD int read_header();
  42. ! 
  43. ! #if (CHIP == M68000)
  44. ! FORWARD int relocate();
  45.   #endif
  46. ***************
  47. *** 48,52 ****
  48.     int m, r, fd, ft;
  49. !   char mbuf[MAX_ISTACK_BYTES];    /* buffer for stack and zeroes */
  50.     union u {
  51. !     char name_buf[MAX_PATH];    /* the name of the file to exec */
  52.       char zb[ZEROBUF_SIZE];    /* used to zero bss */
  53. --- 53,57 ----
  54.     int m, r, fd, ft;
  55. !   char mbuf[ARG_MAX];    /* buffer for stack and zeroes */
  56.     union u {
  57. !     char name_buf[PATH_MAX];/* the name of the file to exec */
  58.       char zb[ZEROBUF_SIZE];    /* used to zero bss */
  59. ***************
  60. *** 63,66 ****
  61.     stk_bytes = (vir_bytes) stack_bytes;
  62. !   if (stk_bytes > MAX_ISTACK_BYTES) return(ENOMEM);    /* stack too big */
  63. !   if (exec_len <= 0 || exec_len > MAX_PATH) return(EINVAL);
  64.   
  65. --- 68,71 ----
  66.     stk_bytes = (vir_bytes) stack_bytes;
  67. !   if (stk_bytes > ARG_MAX) return(ENOMEM);    /* stack too big */
  68. !   if (exec_len <= 0 || exec_len > PATH_MAX) return(EINVAL);
  69.   
  70. ***************
  71. *** 78,80 ****
  72.     sc = (stk_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
  73. !   m = read_header(fd, &ft, &text_bytes, &data_bytes, &bss_bytes, &tot_bytes, &sym_bytes, sc);
  74.     if (m < 0) {
  75. --- 83,86 ----
  76.     sc = (stk_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
  77. !   m = read_header(fd, &ft, &text_bytes, &data_bytes, &bss_bytes, 
  78. !                         &tot_bytes, &sym_bytes, sc);
  79.     if (m < 0) {
  80. ***************
  81. *** 113,115 ****
  82.     load_seg(fd, D, data_bytes);
  83. ! #ifdef ATARI_ST
  84.     if (lseek(fd, sym_bytes, 1) < 0)
  85. --- 119,121 ----
  86.     load_seg(fd, D, data_bytes);
  87. ! #if (CHIP == M68000)
  88.     if (lseek(fd, sym_bytes, 1) < 0)
  89. ***************
  90. *** 122,131 ****
  91.     /* Take care of setuid/setgid bits. */
  92. !   if (s_buf.st_mode & I_SET_UID_BIT) {
  93. !     rmp->mp_effuid = s_buf.st_uid;
  94. !     tell_fs(SETUID, who, (int) rmp->mp_realuid, (int) rmp->mp_effuid);
  95.     }
  96. -   if (s_buf.st_mode & I_SET_GID_BIT) {
  97. -     rmp->mp_effgid = s_buf.st_gid;
  98. -     tell_fs(SETGID, who, (int) rmp->mp_realgid, (int) rmp->mp_effgid);
  99. -   }
  100.   
  101. --- 128,139 ----
  102.     /* Take care of setuid/setgid bits. */
  103. !   if ((rmp->mp_flags & TRACED) == 0) { /* suppress if tracing */
  104. !     if (s_buf.st_mode & I_SET_UID_BIT) {
  105. !         rmp->mp_effuid = s_buf.st_uid;
  106. !         tell_fs(SETUID, who, (int) rmp->mp_realuid, (int) rmp->mp_effuid);
  107. !     }
  108. !     if (s_buf.st_mode & I_SET_GID_BIT) {
  109. !         rmp->mp_effgid = s_buf.st_gid;
  110. !         tell_fs(SETGID, who, (int) rmp->mp_realgid, (int) rmp->mp_effgid);
  111. !     }
  112.     }
  113.   
  114. ***************
  115. *** 136,138 ****
  116.     new_sp = (char *) vsp;
  117. !   sys_exec(who, new_sp);
  118.     return(OK);
  119. --- 144,146 ----
  120.     new_sp = (char *) vsp;
  121. !   sys_exec(who, new_sp, rmp->mp_flags & TRACED);
  122.     return(OK);
  123. ***************
  124. *** 144,146 ****
  125.    *===========================================================================*/
  126. ! PRIVATE int read_header(fd, ft, text_bytes, data_bytes, bss_bytes, tot_bytes, sym_bytes, sc)
  127.   int fd;                /* file descriptor for reading exec file */
  128. --- 152,155 ----
  129.    *===========================================================================*/
  130. ! PRIVATE int read_header(fd, ft, text_bytes, data_bytes, bss_bytes, 
  131. !                             tot_bytes, sym_bytes, sc)
  132.   int fd;                /* file descriptor for reading exec file */
  133. ***************
  134. *** 171,180 ****
  135.      *    7: size of symbol table in bytes
  136. ! #ifdef i8088
  137. !    * The longs are represented low-order byte first and high-order byte last.
  138. !    * The first byte of the header is always 0x01, followed by 0x03.
  139. ! #endif
  140. ! #ifdef ATARI_ST
  141. !    * The longs are represented high-order byte first and low-order byte last.
  142. !    * The third byte of the header is always 0x03, followed by 0x01.
  143. ! #endif
  144.      * The header is followed directly by the text and data segments, whose sizes
  145. --- 180,183 ----
  146.      *    7: size of symbol table in bytes
  147. !    * The longs are represented in a machine dependent order,
  148. !    * little-endian on the 8088, big-endian on the 68000.
  149.      * The header is followed directly by the text and data segments, whose sizes
  150. ***************
  151. *** 196,198 ****
  152.     if (*ft != SEPARATE) {
  153. ! #ifndef ATARI_ST
  154.       /* If I & D space is not separated, it is all considered data. Text=0 */
  155. --- 199,201 ----
  156.     if (*ft != SEPARATE) {
  157. ! #if (CHIP != M68000)
  158.       /* If I & D space is not separated, it is all considered data. Text=0 */
  159. ***************
  160. *** 252,256 ****
  161.     phys_clicks new_base;
  162. !   extern phys_clicks alloc_mem();
  163. !   extern phys_clicks max_hole();
  164. ! #ifdef ATARI_ST
  165.     phys_clicks base, size;
  166. --- 255,257 ----
  167.     phys_clicks new_base;
  168. ! #if (CHIP == M68000)
  169.     phys_clicks base, size;
  170. ***************
  171. *** 283,285 ****
  172.     rmp = mp;
  173. ! #ifndef ATARI_ST
  174.     old_clicks = (phys_clicks) rmp->mp_seg[S].mem_len;
  175. --- 284,286 ----
  176.     rmp = mp;
  177. ! #if (CHIP != M68000)
  178.     old_clicks = (phys_clicks) rmp->mp_seg[S].mem_len;
  179. ***************
  180. *** 301,303 ****
  181.     rmp->mp_seg[S].mem_phys = rmp->mp_seg[D].mem_phys + data_clicks + gap_clicks;
  182. ! #ifdef ATARI_ST
  183.     rmp->mp_seg[T].mem_vir = rmp->mp_seg[T].mem_phys;
  184. --- 302,304 ----
  185.     rmp->mp_seg[S].mem_phys = rmp->mp_seg[D].mem_phys + data_clicks + gap_clicks;
  186. ! #if (CHIP == M68000)
  187.     rmp->mp_seg[T].mem_vir = rmp->mp_seg[T].mem_phys;
  188. ***************
  189. *** 310,312 ****
  190.   #endif
  191. ! #ifdef ATARI_ST
  192.     sys_fresh(who, rmp->mp_seg, (phys_clicks)(data_bytes >> CLICK_SHIFT),
  193. --- 311,313 ----
  194.   #endif
  195. ! #if (CHIP == M68000)
  196.     sys_fresh(who, rmp->mp_seg, (phys_clicks)(data_bytes >> CLICK_SHIFT),
  197. ***************
  198. *** 342,345 ****
  199.    *===========================================================================*/
  200. ! PRIVATE patch_ptr(stack, base)
  201. ! char stack[MAX_ISTACK_BYTES];    /* pointer to stack image within MM */
  202.   vir_bytes base;            /* virtual address of stack base inside user */
  203. --- 343,346 ----
  204.    *===========================================================================*/
  205. ! PRIVATE void patch_ptr(stack, base)
  206. ! char stack[ARG_MAX];    /* pointer to stack image within MM */
  207.   vir_bytes base;            /* virtual address of stack base inside user */
  208. ***************
  209. *** 359,361 ****
  210.     while (flag < 2) {
  211. !     if (ap >= (char **) &stack[MAX_ISTACK_BYTES]) return;    /* too bad */
  212.       if (*ap != NIL_PTR) {
  213. --- 360,362 ----
  214.     while (flag < 2) {
  215. !     if (ap >= (char **) &stack[ARG_MAX]) return;    /* too bad */
  216.       if (*ap != NIL_PTR) {
  217. ***************
  218. *** 375,377 ****
  219.    *===========================================================================*/
  220. ! PRIVATE load_seg(fd, seg, seg_bytes)
  221.   int fd;                /* file descriptor to read from */
  222. --- 376,378 ----
  223.    *===========================================================================*/
  224. ! PRIVATE void load_seg(fd, seg, seg_bytes)
  225.   int fd;                /* file descriptor to read from */
  226. ***************
  227. *** 396,398 ****
  228.     while (seg_bytes) {
  229. !     bytes = 16*1024;        /* could be 32767 */
  230.       if (seg_bytes < bytes)
  231. --- 397,399 ----
  232.     while (seg_bytes) {
  233. !     bytes = 31*1024;        /* <= 32767 */
  234.       if (seg_bytes < bytes)
  235. ***************
  236. *** 406,408 ****
  237.   
  238. ! #ifdef ATARI_ST
  239.   /*===========================================================================*
  240. --- 407,409 ----
  241.   
  242. ! #if (CHIP == M68000)
  243.   /*===========================================================================*
  244. ***************
  245. *** 443,445 ****
  246.     p = buf;
  247. !   n = read(fd, p, MAX_ISTACK_BYTES);
  248.     if (n < sizeof(long))
  249. --- 444,446 ----
  250.     p = buf;
  251. !   n = read(fd, p, ARG_MAX);
  252.     if (n < sizeof(long))
  253. ***************
  254. *** 457,459 ****
  255.               p = buf;
  256. !             n = read(fd, p, MAX_ISTACK_BYTES);
  257.               if (--n < 0)
  258. --- 45